home *** CD-ROM | disk | FTP | other *** search
/ Young Minds / Young Minds Interactive CD-ROM.ISO / sdi / control_.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-08-08  |  6.0 KB  |  263 lines
  1. /*****************************  control_procs.c  ******************************/
  2. #include "sdi.h"
  3. #include <sunwindow/notify.h>
  4.  
  5. /*
  6.  * Copyright 1987 by Mark Weiser.
  7.  * Permission to reproduce and use in any manner whatsoever on Suns is granted
  8.  * so long as this copyright and other identifying marks of authorship
  9.  * in the code and the game remain intact and visible.  Use of this code
  10.  * in other products is reserved to me--I'm working on Mac and IBM versions.
  11.  */
  12.  
  13. /*
  14.  * All the notification procs for the control panel are here.
  15.  * Other control panel-related code is in control.c, helpers.c, and main.c.
  16.  */
  17.  
  18. extern Panel_item timeout_item, rock_item;
  19. void suspend_proc(), resume_proc();
  20.  
  21. /*
  22.  * Proc called when changing the slider for basic update time of the game display
  23.  */
  24. void
  25. cycle_time_proc(item, value, event)
  26. Panel_item item;
  27. Event *event;
  28. {
  29.     blast_delay = value*1000;
  30. }
  31.  
  32. /*
  33.  * Proc called when changing the slider for ballistic flight delay.
  34.  */
  35. void
  36. ballistic_time_proc(item, value, event)
  37. Panel_item item;
  38. Event *event;
  39. {
  40.     extern int ballistic_delay;
  41.     ballistic_delay = value;
  42. }
  43.  
  44. /*
  45.  * Proc called for the 'quit' button.  Tries to completely exit the game.
  46.  */
  47. void
  48. quit_proc(item, event)
  49. Panel_item item;
  50. Event *event;
  51. {
  52.     update_scores();
  53.     suspend_proc();
  54.     window_done(controlframe);
  55.     do_with_delay(resume_proc, 2, 0); /* in case the quit is refused. */
  56. }
  57.  
  58. /*
  59.  * Proc called to skip to the next round in response to the 'next round' button.
  60.  */
  61. void
  62. next_round_proc()
  63. {
  64.     extern void init_blast(), start_running_proc();
  65.     running = 0;
  66.     free_all_blasts();
  67.     free_all_missiles();
  68.     put_text(75, "Click to start next round.");
  69. }
  70.  
  71. /*
  72.  * Proc called to start a new game, usually in response to the 'new game' button.
  73.  */
  74. void
  75. new_game_proc()
  76. {
  77.     extern Panel_item foe_ground_item;
  78.     extern int restoring_game;
  79.     extern int time_to_play;
  80.     void restore_proc();
  81.     running = 0;
  82.     if (restoring_game) {
  83.         restore_proc();
  84.     } else {
  85.         update_scores();
  86.         panel_set_value(level_item, "0");
  87.         panel_set_value(score_item, "0");
  88.         panel_set_value(interceptor_item, 0);
  89.         panel_set_value(laser_item, 0);
  90.         panel_set_value(foe_ground_item, 0);
  91.         panel_set_value(foe_item, 0);
  92.         panel_set_value(total_foe_item, "0");
  93.         panel_set_value(rock_item, 0);
  94.         panel_set_value(ballistic_item, 0);
  95.         
  96.     }
  97.  
  98.     while (suspended)
  99.         resume_proc();
  100.     free_all_blasts();
  101.     free_all_missiles();
  102.     init_intersect();
  103.  
  104.     num_cities = 0;
  105.     total_cities_lost = 0;
  106.     draw_background();
  107.     init_cities();
  108.     panel_set(skill_item, PANEL_EVENT_PROC, panel_default_handle_event, 0);
  109.     panel_set(next_round_item, PANEL_SHOW_ITEM, TRUE, 0);
  110.  
  111.     put_text(75, "Click to start a new game.");
  112.     if (time_to_play) {
  113.         panel_set_value(timeout_item, time_to_play);
  114.     }
  115. }
  116.  
  117. /*
  118.  * Proc called to temporarily suspend a game, usually from the 'suspend' button.
  119.  */
  120. void
  121. suspend_proc()
  122. {
  123.     if (! suspended) {
  124.         panel_set(suspend_item, PANEL_SHOW_ITEM, FALSE, 0);
  125.         panel_set(resume_item, PANEL_SHOW_ITEM, TRUE, 0);
  126.     }
  127.     suspended += 1;
  128. }
  129.  
  130. /*
  131.  * Proc called to resume a suspended game, usually called via the 'resume' button,
  132.  * which is only displayed after a 'suspend'.
  133.  */
  134. void
  135. resume_proc()
  136. {
  137.     if (suspended) {
  138.         suspended -= 1;
  139.         if (! suspended) {
  140.             panel_set(resume_item, PANEL_SHOW_ITEM, FALSE, 0);
  141.             panel_set(suspend_item, PANEL_SHOW_ITEM, TRUE, 0);
  142.         }
  143.     }
  144. }
  145.  
  146. /*
  147.  * Proc called to display the scores from the score file in a popup window.
  148.  */
  149. void
  150. scores_proc(item, value, event)
  151. Panel_item item;
  152. Event *event;
  153. {
  154.     Menu m;
  155.     int id = event_id(event);
  156.     char *a;
  157.     a = (char *)build_scores();
  158.     easy_pop(a);
  159. }
  160.  
  161. /*
  162.  * Proc called to melt all the cities and then end the game, thus forcing all normal
  163.  * end-of-game actions.  Usually called via the 'melt' button.
  164.  */
  165. void
  166. end_proc(item, event)
  167. Panel_item item;
  168. Event event;
  169. {
  170.     free_all_blasts();
  171.     free_all_missiles();
  172.     panel_set_value(ballistic_item, 0);
  173.     melt_all_cities(citypw, 1);
  174.     finish_round();
  175. }
  176.  
  177. /*
  178.  * Toggle the write-ability of important panel items in response
  179.  * to the 'gamemaster' toggle (only visible in gamemaster mode.)
  180.  */
  181. void
  182. master_proc(item, value, event)
  183. Panel_item item;
  184. Event *event;
  185. {
  186.     extern Panel_item foe_ground_item;
  187.     if (value) {
  188.         panel_set(level_item, PANEL_EVENT_PROC, panel_default_handle_event, 0); 
  189.         panel_set(score_item, PANEL_EVENT_PROC, panel_default_handle_event, 0); 
  190.         panel_set(interceptor_item, PANEL_EVENT_PROC, panel_default_handle_event, 0); 
  191.         panel_set(foe_ground_item, PANEL_EVENT_PROC, panel_default_handle_event, 0); 
  192.         panel_set(foe_item, PANEL_EVENT_PROC, panel_default_handle_event, 0); 
  193.         panel_set(laser_item, PANEL_EVENT_PROC, panel_default_handle_event, 0); 
  194.         panel_set(rock_item, PANEL_EVENT_PROC, panel_default_handle_event, 0); 
  195.     } else {
  196.         panel_set(level_item, PANEL_EVENT_PROC, (char *)no_events, 0); 
  197.         panel_set(score_item, PANEL_EVENT_PROC, (char *)no_events, 0); 
  198.         panel_set(interceptor_item, PANEL_EVENT_PROC, (char *)no_events, 0); 
  199.         panel_set(foe_ground_item, PANEL_EVENT_PROC, (char *)no_events, 0);
  200.         panel_set(foe_item, PANEL_EVENT_PROC, (char *)no_events, 0);
  201.         panel_set(laser_item, PANEL_EVENT_PROC, (char *)no_events, 0);
  202.         panel_set(rock_item, PANEL_EVENT_PROC, (char *)no_events, 0);
  203.     }
  204. }
  205.  
  206. void
  207. restore_proc()
  208. {
  209.     void restore_timer_proc();
  210.     if (running) {
  211.         easy_pop("Can only save or restore between rounds.");
  212.         return;
  213.     }
  214.     restoring_game = 1;
  215.     restore_game();
  216.  
  217.     /*
  218.      * the kludge below puts us to sleep for a moment, and then turns
  219.      * off a control variable.  This helps manage an infinite regress
  220.      * which can start if the 'restore_game' call above resizes windows.
  221.      *
  222.      * What I really need are genuine light-weight processes.
  223.      */
  224.     do_with_delay(restore_timer_proc, 0, 500000);
  225. }
  226.  
  227. void
  228. restore_timer_proc()
  229. {
  230.     extern int restoring_game;
  231.     restoring_game = 0;
  232. }
  233.  
  234. void
  235. save_proc()
  236. {
  237.     if (running) {
  238.         easy_pop("Can only save or restore between rounds.");
  239.     } else {
  240.         save_game();
  241.     }
  242. }
  243.  
  244. void
  245. cursor_notify_proc(item, value, event)
  246. Panel_item item;
  247. Event *event;
  248. {
  249.     extern int cursor_type;
  250.     cursor_type = value;
  251.     init_cursor();
  252.     update_cursor();
  253. }
  254.  
  255. void
  256. non_stop_notify_proc(item, value, event)
  257. Panel_item item;
  258. Event *event;
  259. {
  260.     extern int continuous;
  261.     continuous = value;
  262. }
  263.